/** 计算出所有数据 */
export const computedAllData = (csvData: any[]) => {
  const emptyIndex = csvData.findIndex((item) => !item.length);
  const baseOur = arrayToObjectArray(csvData.slice(1, emptyIndex));
  const baseEnemy = arrayToObjectArray(csvData.slice(emptyIndex + 2, csvData.length));

  return {
    /** 基础数据 */
    base: {
      our: baseOur,
      enemy: baseEnemy,
    },
    allocation: {
      our: allocation(baseOur),
      enemy: allocation(baseEnemy),
    },
    overview: {
      our: {
        occupation: overviewByOccupation(baseOur),
        group: overviewByGroup(baseOur),
      },
      enemy: {
        occupation: overviewByOccupation(baseEnemy),
        group: overviewByGroup(baseEnemy),
      },
    },
    datas: {
      our: allDatas(baseOur),
      enemy: allDatas(baseEnemy),
    },
    groupDatas: {
      our: groupDatas(baseOur),
      enemy: groupDatas(baseEnemy),
    },
  };
};

/** array转换为对象array，计算部分值 */
const arrayToObjectArray = (array: any[]) => {
  let arr: any[] = [];
  const allKillCount = array.reduce((sums, item) => {
    const [帮会名, 玩家, 等级, 职业, 团长, 击败, 助攻, 战备资源, 人伤, 塔伤, 治疗值, 承伤, 重伤, 青灯焚骨, 战复, 控制] = item;
    return sums + 击败;
  }, 0);
  const utils = (item) => {
    const [帮会名, 玩家, 等级, 职业, 团长, 击败, 助攻, 战备资源, 人伤, 塔伤, 治疗值, 承伤, 重伤, 青灯焚骨, 战复, 控制] = item;
    let data = 0;
    if (职业 == "铁衣") {
      data = (控制 * 20000) / 承伤;
    } else if (职业 == "素问") {
      data = 治疗值 / (承伤 || 1);
    } else {
      data = (人伤 + 塔伤) / 承伤;
    }
    return parseFloat(Number(data).toFixed(2));
  };
  array.map((item: any) => {
    const [帮会名, 玩家, 等级, 职业, 团长, 击败, 助攻, 战备资源, 人伤, 塔伤, 治疗值, 承伤, 重伤, 青灯焚骨, 战复, 控制] = item;
    arr.push({
      帮会名,
      玩家,
      等级,
      职业,
      团长,
      击败,
      助攻,
      战备资源,
      人伤,
      塔伤,
      治疗值,
      承伤,
      重伤,
      青灯焚骨,
      战复,
      控制,
      总伤: 人伤 + 塔伤,
      KDA: parseFloat(Number((击败 + (1 / 3) * 助攻) / (重伤 + 1)).toFixed(2)),
      伤害效率: parseFloat(Number(人伤 / (击败 + 助攻 || 1) / 10000).toFixed(2)),
      转换系数: utils(item),
      参团率: parseFloat(Number((击败 + 助攻) / allKillCount).toFixed(2)),
    });
  });
  return arr;
};

/** 计算职业配比数据 */
const allocation = (datas: any[]) => {
  const list: any = {};
  datas.map((item) => {
    const { 职业 } = item;
    if (!list[职业]) {
      list[职业] = 1;
    } else {
      list[职业]++;
    }
  });
  const res: any[] = [];
  Object.keys(list).map((职业, index) => {
    res.push({
      职业,
      count: list[职业],
    });
  });
  return res;
};

/** 概览-按职业 */
const overviewByOccupation = (datas: any[]) => {
  const occupation = {};
  datas.map((item) => {
    const { 职业, 击败, 助攻, 战备资源, 人伤, 塔伤, 治疗值, 承伤, 重伤, 青灯焚骨, 战复, 控制, 总伤, 参团率 } = item;
    if (!occupation[职业]) {
      occupation[职业] = { 人数: 1, 击败, 助攻, 战备资源, 人伤, 塔伤, 治疗值, 承伤, 重伤, 青灯焚骨, 战复, 控制, 总伤, 参团率 };
    } else {
      Object.keys(occupation[职业]).map((key, value) => {
        occupation[职业][key] = parseFloat(Number(occupation[职业][key] + (item[key] || 1)).toFixed(2));
      });
    }
  });
  const list: any[] = [];
  Object.keys(occupation).map((职业) => {
    list.push({ 职业, ...occupation[职业] });
  });
  // 计算各项值的吕布
  const occupationMax = list.reduce((acc, obj) => {
    Object.keys(obj).forEach((key) => {
      acc[key] = Math.max(acc[key] || 0, obj[key]);
    });
    return acc;
  }, {});
  const occupationData = list;
  return {
    list: occupationData,
    max: occupationMax,
  };
};

/**  概览-按团 */
const overviewByGroup = (datas: any[]) => {
  const group = {};
  datas.map((item) => {
    const { 团长, 击败, 助攻, 战备资源, 人伤, 塔伤, 治疗值, 承伤, 重伤, 青灯焚骨, 战复, 控制, 总伤, 参团率 } = item;
    if (!group[团长]) {
      group[团长] = { 人数: 1, 击败, 助攻, 战备资源, 人伤, 塔伤, 治疗值, 承伤, 重伤, 青灯焚骨, 战复, 控制, 总伤, 参团率 };
    } else {
      Object.keys(group[团长]).map((key, value) => {
        group[团长][key] = parseFloat(Number(group[团长][key] + (item[key] || 1)).toFixed(2));
      });
    }
  });
  const list: any[] = [];
  Object.keys(group).map((团长) => {
    list.push({ 团长, ...group[团长] });
  });
  // 计算各项值的吕布
  const groupMax = list.reduce((acc, obj) => {
    Object.keys(obj).forEach((key) => {
      acc[key] = Math.max(acc[key] || 0, obj[key]);
    });
    return acc;
  }, {});
  const groupData = list;
  return {
    list: groupData,
    max: groupMax,
  };
};

/** 总数据 */
const allDatas = (datas: any[]) => {
  // 计算平均承伤
  const avg =
    (datas.reduce((sums, item) => {
      const { 承伤 } = item;
      return sums + 承伤;
    }, 0) /
      datas.length) *
    0.6;
  // 计算各项值的吕布
  const maxValues = datas.reduce((acc, obj) => {
    Object.keys(obj).forEach((key) => {
      acc[key] = Math.max(acc[key] || 0, obj[key]);
    });
    return acc;
  }, {});
  const list = datas.sort((a, b) => {
    return b["总伤"] - a["总伤"];
  });
  return {
    list,
    max: maxValues,
    avg,
  };
};

/** 团总数据 */
const groupDatas = (datas: any[]) => {
  const group = {};
  // 按团拆分数据
  datas.map((item) => {
    if (!group[item["团长"]]) {
      group[item["团长"]] = [item];
    } else {
      group[item["团长"]].push(item);
    }
  });

  // 排个序
  Object.keys(group).map((团长) => {
    const list = group[团长];
    group[团长] = sortData(list);
  });

  // 计算各项值的吕布
  const groupMax: any = {};
  const groupAvg: any = {};
  Object.keys(group).map((团长) => {
    const list = group[团长];
    // 计算平均承伤
    const avg =
      (list.reduce((sums, item) => {
        const { 承伤 } = item;
        return sums + 承伤;
      }, 0) /
        list.length) *
      0.6;
    const data = list.reduce((acc, obj) => {
      Object.keys(obj).forEach((key) => {
        acc[key] = Math.max(acc[key] || 0, obj[key]);
      });
      return acc;
    }, {});
    groupAvg[团长] = avg;
    groupMax[团长] = data;
  });
  return {
    max: groupMax,
    list: group,
    avg: groupAvg,
  };
};

/** 数据排序 */
const sortData = (arr: any[]) => {
  return arr.sort((a, b) => {
    if (a["职业"] == "铁衣" && b["职业"] == "铁衣") {
      return b["控制"] != a["控制"] ? b["控制"] - a["控制"] : b["伤害效率"] - a["伤害效率"];
    } else if (a["职业"] == "素问" && b["职业"] == "素问") {
      return b["治疗量"] != a["治疗量"]
        ? b["治疗量"] - a["治疗量"]
        : b["战复"] != a["战复"]
        ? b["战复"] - a["战复"]
        : b["重伤"] != a["重伤"]
        ? b["重伤"] - a["重伤"]
        : b["参团率"] - a["参团率"];
    } else if (a["职业"] == "鸿音" && b["职业"] == "鸿音") {
      return b["总伤"] != a["总伤"]
        ? b["总伤"] - a["总伤"]
        : b["伤害效率"] != a["伤害效率"]
        ? b["伤害效率"] - a["伤害效率"]
        : b["转换系数"] != a["转换系数"]
        ? b["转换系数"] - a["转换系数"]
        : b["转换系数"] != a["转换系数"]
        ? b["参团率"] - a["参团率"]
        : b["治疗量"] - a["治疗量"];
    } else {
      return b["总伤"] != a["总伤"]
        ? b["总伤"] - a["总伤"]
        : b["伤害效率"] != a["伤害效率"]
        ? b["伤害效率"] - a["伤害效率"]
        : b["转换系数"] != a["转换系数"]
        ? b["转换系数"] - a["转换系数"]
        : b["转换系数"] != a["转换系数"]
        ? b["参团率"] - a["参团率"]
        : b["青灯焚骨"] - a["青灯焚骨"];
    }
  });
};
